//------------------------------------------------------------------------------------//
//                                                                                    //
//               _________        .__  __    __                                       //
//               \_   ___ \_______|__|/  |__/  |_  ___________                        //
//               /    \  \/\_  __ \  \   __\   __\/ __ \_  __ \                       //
//               \     \____|  | \/  ||  |  |  | \  ___/|  | \/                       //
//                \______  /|__|  |__||__|  |__|  \___  >__|                          //
//                       \/                           \/                              //
//                                                                                    //
//    Critter is provided under the MIT License(MIT)                                  //
//    Critter uses portions of other open source software.                            //
//    Please review the LICENSE file for further details.                             //
//                                                                                    //
//    Copyright(c) 2015 Matt Davidson                                                 //
//                                                                                    //
//    Permission is hereby granted, free of charge, to any person obtaining a copy    //
//    of this software and associated documentation files(the "Software"), to deal    //
//    in the Software without restriction, including without limitation the rights    //
//    to use, copy, modify, merge, publish, distribute, sublicense, and / or sell     //
//    copies of the Software, and to permit persons to whom the Software is           //
//    furnished to do so, subject to the following conditions :                       //
//                                                                                    //
//    1. Redistributions of source code must retain the above copyright notice,       //
//    this list of conditions and the following disclaimer.                           //
//    2. Redistributions in binary form must reproduce the above copyright notice,    //
//    this list of conditions and the following disclaimer in the                     //
//    documentation and / or other materials provided with the distribution.          //
//    3. Neither the name of the copyright holder nor the names of its                //
//    contributors may be used to endorse or promote products derived                 //
//    from this software without specific prior written permission.                   //
//                                                                                    //
//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR      //
//    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,        //
//    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE      //
//    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER          //
//    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,   //
//    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN       //
//    THE SOFTWARE.                                                                   //
//                                                                                    //
//------------------------------------------------------------------------------------//
/* Based on code from the OGRE engine:
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/

#ifndef _PixelFormat_H__
#define _PixelFormat_H__

#include <CtrPlatform.h>
#include <CtrRegion.h>
#include <CtrColorValue.h>
#include <CtrVector3.h>
#include <CtrLog.h>

namespace Ctr
{
    enum PixelFormat
    {
        /// Unknown pixel format.
        PF_UNKNOWN = 0,
        /// 8-bit pixel format, all bits luminance.
        PF_L8 = 1,
        PF_BYTE_L = PF_L8,
        /// 16-bit pixel format, all bits luminance.
        PF_L16 = 2,
        PF_SHORT_L = PF_L16,
        /// 8-bit pixel format, all bits alpha.
        PF_A8 = 3,
        PF_BYTE_A = PF_A8,
        /// 8-bit pixel format, 4 bits alpha, 4 bits luminance.
        PF_A4L4 = 4,
        /// 2 byte pixel format, 1 byte luminance, 1 byte alpha
        PF_BYTE_LA = 5,
        /// 16-bit pixel format, 5 bits red, 6 bits green, 5 bits blue.
        PF_R5G6B5 = 6,
        /// 16-bit pixel format, 5 bits red, 6 bits green, 5 bits blue.
        PF_B5G6R5 = 7,
        /// 8-bit pixel format, 2 bits blue, 3 bits green, 3 bits red.
        PF_R3G3B2 = 31,
        /// 16-bit pixel format, 4 bits for alpha, red, green and blue.
        PF_A4R4G4B4 = 8,
        /// 16-bit pixel format, 5 bits for blue, green, red and 1 for alpha.
        PF_A1R5G5B5 = 9,
        /// 24-bit pixel format, 8 bits for red, green and blue.
        PF_R8G8B8 = 10,
        /// 24-bit pixel format, 8 bits for blue, green and red.
        PF_B8G8R8 = 11,
        /// 32-bit pixel format, 8 bits for alpha, red, green and blue.
        PF_A8R8G8B8 = 12,
        /// 32-bit pixel format, 8 bits for blue, green, red and alpha.
        PF_A8B8G8R8 = 13,
        /// 32-bit pixel format, 8 bits for blue, green, red and alpha.
        PF_B8G8R8A8 = 14,
        /// 32-bit pixel format, 8 bits for red, green, blue and alpha.
        PF_R8G8B8A8 = 28,
        /// 32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue
        /// like PF_A8R8G8B8, but alpha will get discarded
        PF_X8R8G8B8 = 26,
        /// 32-bit pixel format, 8 bits for blue, 8 bits for green, 8 bits for red
        /// like PF_A8B8G8R8, but alpha will get discarded
        PF_X8B8G8R8 = 27,
        /// 3 byte pixel format, 1 byte for red, 1 byte for green, 1 byte for blue
        PF_BYTE_RGB = PF_B8G8R8,
        /// 3 byte pixel format, 1 byte for blue, 1 byte for green, 1 byte for red
        PF_BYTE_BGR = PF_R8G8B8,
        /// 4 byte pixel format, 1 byte for blue, 1 byte for green, 1 byte for red and one byte for alpha
        PF_BYTE_BGRA = PF_A8R8G8B8,
        /// 4 byte pixel format, 1 byte for red, 1 byte for green, 1 byte for blue, and one byte for alpha
        PF_BYTE_RGBA = PF_A8B8G8R8,
        /// 32-bit pixel format, 2 bits for alpha, 10 bits for red, green and blue.
        PF_A2R10G10B10 = 15,
        /// 32-bit pixel format, 10 bits for blue, green and red, 2 bits for alpha.
        PF_A2B10G10R10 = 16,
        /// DDS (DirectDraw Surface) DXT1 format
        PF_DXT1 = 17,
        /// DDS (DirectDraw Surface) DXT2 format
        PF_DXT2 = 18,
        /// DDS (DirectDraw Surface) DXT3 format
        PF_DXT3 = 19,
        /// DDS (DirectDraw Surface) DXT4 format
        PF_DXT4 = 20,
        /// DDS (DirectDraw Surface) DXT5 format
        PF_DXT5 = 21,
        // 16-bit pixel format, 16 bits (float) for red
        PF_FLOAT16_R = 32,
        // 48-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue
        PF_FLOAT16_RGB = 22,
        // 64-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue, 16 bits (float) for alpha
        PF_FLOAT16_RGBA = 23,
        // 32-bit pixel format, 32 bits (float) for red
        PF_FLOAT32_R = 33,
        // 96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
        PF_FLOAT32_RGB = 24,
        // 128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha
        PF_FLOAT32_RGBA = 25,
        // 32-bit, 2-channel s10e5 floating point pixel format, 16-bit green, 16-bit red
        PF_FLOAT16_GR = 35,
        // 64-bit, 2-channel floating point pixel format, 32-bit green, 32-bit red
        PF_FLOAT32_GR = 36,
        // Depth texture format
        PF_DEPTH = 29,
        // 64-bit pixel format, 16 bits for red, green, blue and alpha
        PF_SHORT_RGBA = 30,
        // 32-bit pixel format, 16-bit green, 16-bit red
        PF_SHORT_GR = 34,
        // 48-bit pixel format, 16 bits for red, green and blue
        PF_SHORT_RGB = 37,
        /// PVRTC (PowerVR) RGB 2 bpp
        PF_PVRTC_RGB2 = 38,
        /// PVRTC (PowerVR) RGBA 2 bpp
        PF_PVRTC_RGBA2 = 39,
        /// PVRTC (PowerVR) RGB 4 bpp
        PF_PVRTC_RGB4 = 40,
        /// PVRTC (PowerVR) RGBA 4 bpp
        PF_PVRTC_RGBA4 = 41,
        /// 8-bit pixel format, all bits red.
        PF_R8 = 42,
        /// 16-bit pixel format, 8 bits red, 8 bits green.
        PF_RG8 = 43,
        // Depth 16
        PF_DEPTH16 = 44,
        // Depth 32
        PF_DEPTH32 = 45,
        // Depth 24 Stencil 8
        PF_DEPTH24S8 = 46,
        // Number of pixel formats currently defined
        PF_COUNT = 47,
    };
    typedef std::vector<PixelFormat> PixelFormatList;

    enum PixelFormatFlags {
        // This format has an alpha channel
        PFF_HASALPHA        = 0x00000001,      
        // This format is compressed. This invalidates the values in elemBytes,
        // elemBits and the bit counts as these might not be fixed in a compressed format.
        PFF_COMPRESSED    = 0x00000002,
        // This is a floating point format
        PFF_FLOAT           = 0x00000004,         
        // This is a depth format (for depth textures)
        PFF_DEPTH           = 0x00000008,
        // Format is in native endian. Generally true for the 16, 24 and 32 bits
        // formats which can be represented as machine integers.
        PFF_NATIVEENDIAN    = 0x00000010,
        // This is an intensity format instead of a RGB one. The luminance
        // replaces R,G and B. (but not A)
        PFF_LUMINANCE       = 0x00000020
    };
    
    enum PixelComponentType
    {
        PCT_BYTE = 0,    /// Byte per component (8 bit fixed 0.0..1.0)
        PCT_SHORT = 1,   /// Short per component (16 bit fixed 0.0..1.0))
        PCT_FLOAT16 = 2, /// 16 bit float per component
        PCT_FLOAT32 = 3, /// 32 bit float per component
        PCT_COUNT = 4    /// Number of pixel types
    };
    
    typedef Ctr::Vector3<size_t> Vector3ui;
    typedef Ctr::Region <Vector3ui > Region3ui;
    class PixelBox: public Region3ui {
    public:
        /// Parameter constructor for setting the members manually
        PixelBox() {}
        ~PixelBox() {}
        /** Constructor providing extents in the form of a Region3i object. This constructor
            assumes the pixel data is laid out consecutively in memory. (this
            means row after row, slice after slice, with no space in between)
            @param extents        Extents of the region defined by data
            @param pixelFormat    Format of this buffer
            @param pixelData    Pointer to the actual data
        */
        PixelBox(const Region3ui &extents, PixelFormat pixelFormat, void *pixelData=0):
            Region3ui(extents), data(pixelData), format(pixelFormat)
        {
            setConsecutive();
        }
        /** Constructor providing width, height and depth. This constructor
            assumes the pixel data is laid out consecutively in memory. (this
            means row after row, slice after slice, with no space in between)
            @param width        Width of the region
            @param height        Height of the region
            @param depth        Depth of the region
            @param pixelFormat    Format of this buffer
            @param pixelData    Pointer to the actual data
        */
        PixelBox(size_t width, size_t height, size_t depth, PixelFormat pixelFormat, void *pixelData=0):
            Region3ui(Ctr::Vector3ui(0, 0, 0), Ctr::Vector3ui(width, height, depth)),
            data(pixelData), format(pixelFormat)
        {
            setConsecutive();
        }

        uint32_t getNumChannels() const
        {
            /// Unknown pixel format.
            switch (format)
            {
                case PF_UNKNOWN:
                    return 0;
                case PF_L8:
                case PF_L16:
                case PF_A8:
                    return 1;
                case PF_R8G8B8:
                case PF_B8G8R8:
                    return 3;
                case PF_A8R8G8B8:
                case PF_A8B8G8R8:
                case PF_B8G8R8A8:
                case PF_R8G8B8A8:
                case PF_X8R8G8B8:
                case PF_X8B8G8R8:
                    return 4;
                case PF_FLOAT16_R:
                    return 1;
                case PF_FLOAT16_RGB:
                    return 3;
                case PF_FLOAT16_RGBA:
                    return 4;
                case PF_FLOAT32_R:
                    return 1;
                case PF_FLOAT32_RGB:
                    return 3;
                case PF_FLOAT32_RGBA:
                    return 4;
                case PF_FLOAT16_GR:
                    return 2;
                case PF_FLOAT32_GR:
                    return 2;
                case PF_DEPTH:
                    return 1;
                case PF_SHORT_RGBA:
                    return 4;
                case PF_SHORT_GR:
                    return 2;
                case PF_SHORT_RGB:
                    return 3;
                case PF_R8:
                     return 1;
                case PF_RG8:
                    return 2;
              }

              LOG ("Error while attempting to find channel count");
              return 0;
        }
        
        /// The data pointer 
        void *data;
        /// The pixel format 
        PixelFormat format;
        /** Number of elements between the leftmost pixel of one row and the left
             pixel of the next. This value must always be equal to size().x (consecutive) 
            for compressed formats.
        */
        size_t rowPitch;
        /** Number of elements between the top left pixel of one (depth) slice and 
             the top left pixel of the next. This can be a negative value. Must be a multiple of
             rowPitch. This value must always be equal to size().x*size().y (consecutive) 
            for compressed formats.
        */
        size_t slicePitch;
        
        /** Set the rowPitch and slicePitch so that the buffer is laid out consecutive 
             in memory.
        */        
        void setConsecutive()
        {
            rowPitch = size().x;
            slicePitch = size().x*size().y;
        }
        /**    Get the number of elements between one past the rightmost pixel of 
             one row and the leftmost pixel of the next row. (IE this is zero if rows
             are consecutive).
        */
        size_t getRowSkip() const { return rowPitch - size().x; }
        /** Get the number of elements between one past the right bottom pixel of
             one slice and the left top pixel of the next slice. (IE this is zero if slices
             are consecutive).
        */
        size_t getSliceSkip() const { return slicePitch - (size().y * rowPitch); }

        /** Return whether this buffer is laid out consecutive in memory (ie the pitches
             are equal to the dimensions)
        */        
        bool isConsecutive() const 
        { 
            return rowPitch == size().x && slicePitch == size().x*size().y; 
        }
        /** Return the size (in bytes) this image would take if it was
            laid out consecutive in memory
          */
          size_t getConsecutiveSize() const;
          /** Return a subvolume of this PixelBox.
              @param def    Defines the bounds of the subregion to return
              @return    A pixel box describing the region and the data in it
              @remarks    This function does not copy any data, it just returns
                  a PixelBox object with a data pointer pointing somewhere inside 
                  the data of object.
              @throws    Exception(ERR_INVALIDPARAMS) if def is not fully contained
          */
          PixelBox getSubVolume(const Region3ui &def) const;
        
        /**
         * Get colour value from a certain location in the PixelBox. The z coordinate
         * is only valid for cubemaps and volume textures. This uses the first (largest)
         * mipmap.
         */
        ColorValue getColorAt(size_t x, size_t y, size_t z);

        /**
         * Set colour value at a certain location in the PixelBox. The z coordinate
         * is only valid for cubemaps and volume textures. This uses the first (largest)
         * mipmap.
         */
        void setColorAt(ColorValue const &cv, size_t x, size_t y, size_t z);
    };
    

    /**
     * Some utility functions for packing and unpacking pixel data
     */
    class PixelUtil {
    public:
        /** Returns the size in bytes of an element of the given pixel format.
         @return
               The size in bytes of an element. See Remarks.
         @remarks
               Passing PF_UNKNOWN will result in returning a size of 0 bytes.
        */
        static size_t getNumElemBytes( PixelFormat format );

        /** Returns the size in bits of an element of the given pixel format.
          @return
               The size in bits of an element. See Remarks.
           @remarks
               Passing PF_UNKNOWN will result in returning a size of 0 bits.
        */
        static size_t getNumElemBits( PixelFormat format );

        /** Returns the size in memory of a region with the given extents and pixel
            format with consecutive memory layout.
            @param width
                The width of the area
            @param height
                The height of the area
            @param depth
                The depth of the area
            @param format
                The format of the area
              @return
                  The size in bytes
            @remarks
                In case that the format is non-compressed, this simply returns
                width*height*depth*PixelUtil::getNumElemBytes(format). In the compressed
                case, this does serious magic.
        */
        static size_t getMemorySize(size_t width, size_t height, size_t depth, PixelFormat format);
        
        /** Returns the property flags for this pixel format
          @return
               A bitfield combination of PFF_HASALPHA, PFF_ISCOMPRESSED,
               PFF_FLOAT, PFF_DEPTH, PFF_NATIVEENDIAN, PFF_LUMINANCE
          @remarks
               This replaces the separate functions for formatHasAlpha, formatIsFloat, ...
        */
        static unsigned int getFlags( PixelFormat format );

        /** Shortcut method to determine if the format has an alpha component */
        static bool hasAlpha(PixelFormat format);
        /** Shortcut method to determine if the format is floating point */
        static bool isFloatingPoint(PixelFormat format);
        /** Shortcut method to determine if the format is compressed */
        static bool isCompressed(PixelFormat format);
        /** Shortcut method to determine if the format is a depth format. */
        static bool isDepth(PixelFormat format);
        /** Shortcut method to determine if the format is in native endian format. */
        static bool isNativeEndian(PixelFormat format);
        /** Shortcut method to determine if the format is a luminance format. */
        static bool isLuminance(PixelFormat format);
        
        /** Return wether a certain image extent is valid for this image format.
            @param width
                The width of the area
            @param height
                The height of the area
            @param depth
                The depth of the area
            @param format
                The format of the area
            @remarks For non-compressed formats, this is always true. For DXT formats,
            only sizes with a width and height multiple of 4 and depth 1 are allowed.
        */
        static bool isValidExtent(size_t width, size_t height, size_t depth, PixelFormat format);

        /** Gives the number of bits (RGBA) for a format. See remarks.          
          @remarks      For non-colour formats (dxt, depth) this returns [0,0,0,0].
        */
        static void getBitDepths(PixelFormat format, int rgba[4]);

        /** Gives the masks for the R, G, B and A component
          @note            Only valid for native endian formats
        */
        static void getBitMasks(PixelFormat format, uint32_t rgba[4]);

        /** Gives the bit shifts for R, G, B and A component
        @note            Only valid for native endian formats
        */
        static void getBitShifts(PixelFormat format, unsigned char rgba[4]);

        /** Gets the name of an image format
        */
        static std::string getFormatName(PixelFormat srcformat);

        /** Returns wether the format can be packed or unpacked with the packColor()
        and unpackColor() functions. This is generally not true for compressed and
        depth formats as they are special. It can only be true for formats with a
        fixed element size.
          @return 
               true if yes, otherwise false
        */
        static bool isAccessible(PixelFormat srcformat);
        
        /** Returns the component type for a certain pixel format. Returns PCT_BYTE
            in case there is no clear component type like with compressed formats.
            This is one of PCT_BYTE, PCT_SHORT, PCT_FLOAT16, PCT_FLOAT32.
        */
        static PixelComponentType getComponentType(PixelFormat fmt);
        
        /** Returns the component count for a certain pixel format. Returns 3(no alpha) or 
            4 (has alpha) in case there is no clear component type like with compressed formats.
         */
        static size_t getComponentCount(PixelFormat fmt);

        /** Gets the format from given name.
            @param  name            The string of format name
            @param  accessibleOnly  If true, non-accessible format will treat as invalid format,
                                    otherwise, all supported format are valid.
            @param  caseSensitive   Should be set true if string match should use case sensitivity.
            @return                The format match the format name, or PF_UNKNOWN if is invalid name.
        */
        static PixelFormat getFormatFromName(const std::string& name, bool accessibleOnly = false, bool caseSensitive = false);



        /** Returns the similar format but acoording with given bit depths.
            @param fmt      The original foamt.
            @param integerBits Preferred bit depth (pixel bits) for integer pixel format.
                            Available values: 0, 16 and 32, where 0 (the default) means as it is.
            @param floatBits Preferred bit depth (channel bits) for float pixel format.
                            Available values: 0, 16 and 32, where 0 (the default) means as it is.
            @return        The format that similar original format with bit depth according
                            with preferred bit depth, or original format if no conversion occurring.
        */
        static PixelFormat getFormatForBitDepths(PixelFormat fmt, uint16_t integerBits, uint16_t floatBits);

        /** Pack a colour value to memory
            @param colour    The colour
            @param pf        Pixelformat in which to write the colour
            @param dest        Destination memory location
        */
        static void packColor(const ColorValue &colour, const PixelFormat pf,  void* dest);
        /** Pack a colour value to memory
            @param r,g,b,a    The four colour components, range 0x00 to 0xFF
            @param pf        Pixelformat in which to write the colour
            @param dest        Destination memory location
        */
        static void packColor(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a, const PixelFormat pf,  void* dest);
         /** Pack a colour value to memory
            @param r,g,b,a    The four colour components, range 0.0f to 1.0f
                            (an exception to this case exists for floating point pixel
                            formats, which don't clamp to 0.0f..1.0f)
            @param pf        Pixelformat in which to write the colour
            @param dest        Destination memory location
        */
        static void packColor(const float r, const float g, const float b, const float a, const PixelFormat pf,  void* dest);

        /** Unpack a colour value from memory
            @param colour    The colour is returned here
            @param pf        Pixelformat in which to read the colour
            @param src        Source memory location
        */
        static void unpackColor(ColorValue *colour, PixelFormat pf,  const void* src);
        /** Unpack a colour value from memory
            @param r,g,b,a    The colour is returned here (as byte)
            @param pf        Pixelformat in which to read the colour
            @param src        Source memory location
            @remarks     This function returns the colour components in 8 bit precision,
                this will lose precision when coming from PF_A2R10G10B10 or floating
                point formats.  
        */
        static void unpackColor(uint8_t *r, uint8_t *g, uint8_t *b, uint8_t *a, PixelFormat pf,  const void* src);
        /** Unpack a colour value from memory
            @param r,g,b,a    The colour is returned here (as float)
            @param pf        Pixelformat in which to read the colour
            @param src        Source memory location
        */
        static void unpackColor(float *r, float *g, float *b, float *a, PixelFormat pf,  const void* src);
        
        /** Convert consecutive pixels from one format to another. No dithering or filtering is being done. 
             Converting from RGB to luminance takes the R channel.  In case the source and destination format match,
             just a copy is done.
             @param    src            Pointer to source region
             @param    srcFormat    Pixel format of source region
             @param   dst            Pointer to destination region
             @param    dstFormat    Pixel format of destination region
         */
        static void bulkPixelConversion(void *src, PixelFormat srcFormat, void *dest, PixelFormat dstFormat, unsigned int count);

          /** Convert pixels from one format to another. No dithering or filtering is being done. Converting
              from RGB to luminance takes the R channel. 
             @param    src            PixelBox containing the source pixels, pitches and format
             @param    dst            PixelBox containing the destination pixels, pitches and format
             @remarks The source and destination boxes must have the same
             dimensions. In case the source and destination format match, a plain copy is done.
        */
        static void bulkPixelConversion(const PixelBox &src, const PixelBox &dst);
    };
    /** @} */
    /** @} */

}

#endif
